<?php
/**
 * 角色权限控制器
 * RESTful API 实现系统角色权限管理
 */

declare (strict_types = 1);

namespace app\controller\home;

use app\BaseController;
use think\facade\Db;
use think\facade\Request;
use app\common\DataPermissionHelper;

class Role extends BaseController
{
    /**
     * 获取角色权限列表（向后兼容方法）
     */
    public function index()
    {
        return $this->list();
    }
    
    /**
     * 获取角色权限列表
     * GET /api/home/role/list
     */
    public function list()
    {
        try {
            $param = Request::param();
            $page = (int)($param['page'] ?? 1);
            $limit = (int)($param['limit'] ?? 20);
            $keywords = trim($param['keywords'] ?? '');
            $status = $param['status'] ?? '';
            
            // 权限检查：只有超级管理员才能查看所有角色
            if (!$this->checkSuperAdmin()) {
                return $this->error('无权限查看角色权限', 403);
            }
            
            // 构建查询条件
            $where = [];
            
            // 关键词搜索
            if (!empty($keywords)) {
                $where[] = ['title|desc', 'like', '%' . $keywords . '%'];
            }
            
            // 状态筛选
            if ($status !== '') {
                $where[] = ['status', '=', (int)$status];
            }
            
            // 查询角色权限列表
            $query = Db::name('admin_group')
                ->where($where)
                ->order('create_time', 'asc');
                
            $total = $query->count();
            $roles = $query->page($page, $limit)->select()->toArray();
            
            // 处理数据格式
            foreach ($roles as &$role) {
                $role = $this->formatRoleData($role);
            }
            
            return $this->paginate($roles, $total, $page, $limit, '获取角色权限列表成功');
        } catch (\Exception $e) {
            return $this->error('查询失败: ' . $e->getMessage(), 500);
        }
    }
    
    /**
     * 格式化角色数据
     */
    private function formatRoleData($role)
    {
        $role['create_time_format'] = $role['create_time'] ? date('Y-m-d H:i:s', $role['create_time']) : '';
        $role['update_time_format'] = $role['update_time'] ? date('Y-m-d H:i:s', $role['update_time']) : '';
        
        // 状态名称
        $statusNames = [
            0 => '禁用',
            1 => '正常'
        ];
        $role['status_name'] = $statusNames[$role['status']] ?? '未知';
        
        // 权限节点
        if (!empty($role['rules'])) {
            $rulesArray = explode(',', trim($role['rules'], ','));
            $role['rules_array'] = array_filter($rulesArray); // 过滤空元素
            $role['rules_count'] = count($role['rules_array']);
        } else {
            $role['rules_array'] = [];
            $role['rules_count'] = 0;
        }
        
        // 首页展示模块
        if (!empty($role['layouts'])) {
            $layoutsArray = explode(',', trim($role['layouts'], ','));
            $role['layouts_array'] = array_filter($layoutsArray); // 过滤空元素
            $role['layouts_count'] = count($role['layouts_array']);
        } else {
            $role['layouts_array'] = [];
            $role['layouts_count'] = 0;
        }
        
        return $role;
    }
    
    /**
     * 查看单个角色权限详情
     * GET /api/home/role/{id}
     */
    public function read()
    {
        try {
            // 获取路径参数id
            $id = (int)Request::route('id');
            $param = Request::param(); // 获取其他查询参数
            
            if ($id <= 0) {
                return $this->paramError('角色ID不能为空');
            }
            
            // 权限检查
            if (!$this->checkSuperAdmin()) {
                return $this->error('无权限查看角色权限', 403);
            }
            
            // 查询角色权限详情
            $role = Db::name('admin_group')
                ->where('id', $id)
                ->find();
            
            if (empty($role)) {
                return $this->error('角色不存在', 404);
            }
            
            $role = $this->formatRoleData($role);
            
            // 获取角色的具体权限节点信息
            if (!empty($role['rules_array'])) {
                $role['rules_detail'] = Db::name('admin_rule')
                    ->whereIn('id', $role['rules_array'])
                    ->field('id, title, name, mig_src, module')
                    ->select()
                    ->toArray();
            } else {
                $role['rules_detail'] = [];
            }
            
            // 获取使用该角色的用户数量
            $role['user_count'] = Db::name('admin')
                ->where('group_id', $id)
                ->count();
            
            return $this->success($role, '获取角色权限详情成功');
        } catch (\Exception $e) {
            return $this->error('查询失败: ' . $e->getMessage(), 500);
        }
    }
    
    /**
     * 创建角色权限
     * POST /api/home/role
     */
    public function save()
    {
        try {
            $param = Request::param();
            
            // 权限检查（只有超级管理员才能操作）
            if (!$this->checkSuperAdmin()) {
                return $this->error('只有系统超级管理员才有权限操作角色！', 403);
            }
            
            // 数据验证
            $validate = $this->validateRoleData($param);
            if ($validate !== true) {
                return $this->paramError($validate);
            }
            
            // 检查角色名称是否已存在
            $existRole = Db::name('admin_group')
                ->where('title', trim($param['title']))
                ->find();
            
            if ($existRole) {
                return $this->error('角色名称已存在', 400);
            }
            
            // 处理权限规则字符串，确保不会自动分配所有节点权限
            $rules = '';
            if (isset($param['rules']) && is_array($param['rules'])) {
                // 过滤掉无效的规则ID
                $validRules = array_filter($param['rules']);
                if (!empty($validRules)) {
                    $rules = ',' . implode(',', $validRules) . ',';
                }
            }
            
            $layouts = '';
            if (isset($param['layouts']) && is_array($param['layouts'])) {
                // 过滤掉无效的布局ID
                $validLayouts = array_filter($param['layouts']);
                if (!empty($validLayouts)) {
                    $layouts = ',' . implode(',', $validLayouts) . ',';
                }
            }
            
            $data = [
                'title' => trim($param['title']),
                'desc' => trim($param['desc'] ?? ''),
                'status' => (int)($param['status'] ?? 1),
                'rules' => $rules,
                'layouts' => $layouts,
                'create_time' => time(),
                'update_time' => time()
            ];
            
            // 创建角色权限
            $roleId = Db::name('admin_group')->insertGetId($data);
            
            return $this->created(['id' => $roleId], '角色权限创建成功');
        } catch (\Exception $e) {
            return $this->error('创建失败: ' . $e->getMessage(), 500);
        }
    }
    
    /**
     * 更新角色权限
     * PUT /api/home/role/{id}
     */
    public function update()
    {
        try {
            // 获取路径参数id
            $id = (int)Request::route('id');
            $param = Request::param(); // 获取其他查询参数
            
            if ($id <= 0) {
                return $this->paramError('角色ID不能为空');
            }
            
            // 权限检查
            if (!$this->checkSuperAdmin()) {
                return $this->error('只有系统超级管理员才有权限操作角色！', 403);
            }
            
            // 检查角色是否存在
            $role = Db::name('admin_group')->where('id', $id)->find();
            if (empty($role)) {
                return $this->error('角色不存在', 404);
            }
            
            // 数据验证
            $validate = $this->validateRoleData($param, $id);
            if ($validate !== true) {
                return $this->paramError($validate);
            }
            
            // 检查角色名称是否已存在（排除自己）
            $existRole = Db::name('admin_group')
                ->where('title', trim($param['title']))
                ->where('id', '<>', $id)
                ->find();
            
            if ($existRole) {
                return $this->error('角色名称已存在', 400);
            }
            
            // 处理权限规则字符串
            $rules = '';
            if (isset($param['rules']) && is_array($param['rules'])) {
                // 过滤掉无效的规则ID
                $validRules = array_filter($param['rules']);
                if (!empty($validRules)) {
                    $rules = ',' . implode(',', $validRules) . ',';
                }
            }
            
            $layouts = '';
            if (isset($param['layouts']) && is_array($param['layouts'])) {
                // 过滤掉无效的布局ID
                $validLayouts = array_filter($param['layouts']);
                if (!empty($validLayouts)) {
                    $layouts = ',' . implode(',', $validLayouts) . ',';
                }
            }
            
            $data = [
                'title' => trim($param['title']),
                'desc' => trim($param['desc'] ?? $role['desc']),
                'status' => (int)($param['status'] ?? $role['status']),
                'rules' => $rules,
                'layouts' => $layouts,
                'update_time' => time()
            ];
            
            // 更新角色权限
            Db::name('admin_group')->where('id', $id)->update($data);
            
            return $this->success('角色权限更新成功');
        } catch (\Exception $e) {
            return $this->error('更新失败: ' . $e->getMessage(), 500);
        }
    }
    
    /**
     * 删除角色权限
     * DELETE /api/home/role/{id}
     */
    public function delete()
    {
        try {
            $param = Request::param();
            $id = (int)($param['id'] ?? 0);
            
            if ($id <= 0) {
                return $this->paramError('角色ID不能为空');
            }
            
            // 权限检查
            if (!$this->checkSuperAdmin()) {
                return $this->error('只有系统超级管理员才有权限操作角色！', 403);
            }
            
            // 检查角色是否存在
            $role = Db::name('admin_group')->where('id', $id)->find();
            if (empty($role)) {
                return $this->error('角色不存在', 404);
            }
            
            // 检查是否有用户使用该角色
            $userCount = Db::name('admin')->where('group_id', $id)->count();
            if ($userCount > 0) {
                return $this->error('该角色已被用户使用，无法删除', 400);
            }
            
            // 删除角色
            Db::name('admin_group')->where('id', $id)->delete();
            
            return $this->deleted('角色权限删除成功');
        } catch (\Exception $e) {
            return $this->error('删除失败: ' . $e->getMessage(), 500);
        }
    }
    
    /**
     * 验证角色数据
     * @param array $param 请求参数
     * @param int $id 角色ID（编辑时使用）
     * @return bool|string 验证通过返回true，否则返回错误信息
     */
    private function validateRoleData($param, $id = 0)
    {
        if (empty($param['title'])) {
            return '角色名称不能为空';
        }
        
        // 验证状态
        if (isset($param['status']) && !in_array($param['status'], [0, 1])) {
            return '状态只能是0（禁用）或1（正常）';
        }
        
        return true;
    }
    
    /**
     * 获取角色列表（向后兼容方法）
     */
    public function set()
    {
        try {
            // 查询启用的角色列表
            $list = Db::name('admin_group')
                ->where('status', 1)
                ->order('id', 'asc')
                ->select()
                ->toArray();
            
            return json([
                'code' => 0,
                'msg' => 'success',
                'data' => $list
            ]);
        } catch (\Exception $e) {
            return json(['code' => 500, 'msg' => '查询失败: ' . $e->getMessage()]);
        }
    }
    
    /**
     * 查看单个角色信息（向后兼容方法）
     */
    public function view()
    {
        try {
            $param = Request::param();
            
            if (empty($param['id'])) {
                return json(['code' => 400, 'msg' => '参数错误']);
            }
            
            // 查询角色详情
            $role = Db::name('admin_group')
                ->where('id', $param['id'])
                ->find();
            
            if (empty($role)) {
                return json(['code' => 404, 'msg' => '角色不存在']);
            }
            
            // 格式化时间
            $role['create_time_format'] = $role['create_time'] ? date('Y-m-d H:i:s', $role['create_time']) : '';
            $role['update_time_format'] = $role['update_time'] ? date('Y-m-d H:i:s', $role['update_time']) : '';
            
            // 状态名称
            $statusNames = [
                0 => '禁用',
                1 => '正常'
            ];
            $role['status_name'] = $statusNames[$role['status']] ?? '未知';
            
            return json([
                'code' => 0,
                'msg' => 'success',
                'data' => $role
            ]);
        } catch (\Exception $e) {
            return json(['code' => 500, 'msg' => '查询失败: ' . $e->getMessage()]);
        }
    }
    
    /**
     * 新建角色（向后兼容方法）
     */
    public function add()
    {
        try {
            $param = Request::param();
            
            // 检查权限（只有超级管理员才能操作）
            if (!$this->checkSuperAdmin()) {
                return json(['code' => 403, 'msg' => '只有系统超级管理员才有权限操作角色！']);
            }
            
            // 数据验证
            if (empty($param['title'])) {
                return json(['code' => 400, 'msg' => '角色名称不能为空']);
            }
            
            // 检查角色名称是否已存在
            $exist = Db::name('admin_group')
                ->where('title', $param['title'])
                ->find();
            
            if ($exist) {
                return json(['code' => 400, 'msg' => '角色名称已存在']);
            }
            
            $data = [
                'title' => $param['title'],
                'desc' => $param['desc'] ?? '',
                'status' => $param['status'] ?? 1,
                'create_time' => time(),
                'update_time' => time()
            ];
            
            // 新建角色
            $roleId = Db::name('admin_group')->insertGetId($data);
            
            return json(['code' => 0, 'msg' => '保存成功', 'data' => ['id' => $roleId]]);
        } catch (\Exception $e) {
            return json(['code' => 500, 'msg' => '保存失败: ' . $e->getMessage()]);
        }
    }
    
    /**
     * 编辑角色（向后兼容方法）
     */
    public function edit()
    {
        try {
            $param = Request::param();
            
            // 检查权限（只有超级管理员才能操作）
            if (!$this->checkSuperAdmin()) {
                return json(['code' => 403, 'msg' => '只有系统超级管理员才有权限操作角色！']);
            }
            
            // 数据验证
            if (empty($param['id'])) {
                return json(['code' => 400, 'msg' => '参数错误']);
            }
            
            if (empty($param['title'])) {
                return json(['code' => 400, 'msg' => '角色名称不能为空']);
            }
            
            // 检查角色是否存在
            $role = Db::name('admin_group')
                ->where('id', $param['id'])
                ->find();
            
            if (empty($role)) {
                return json(['code' => 404, 'msg' => '角色不存在']);
            }
            
            // 检查角色名称是否已存在（排除自己）
            $exist = Db::name('admin_group')
                ->where('title', $param['title'])
                ->where('id', '<>', $param['id'])
                ->find();
            
            if ($exist) {
                return json(['code' => 400, 'msg' => '角色名称已存在']);
            }
            
            $data = [
                'id' => $param['id'],
                'title' => $param['title'],
                'desc' => $param['desc'] ?? $role['desc'],
                'status' => $param['status'] ?? $role['status'],
                'update_time' => time()
            ];
            
            // 更新角色
            Db::name('admin_group')->update($data);
            
            return json(['code' => 0, 'msg' => '更新成功']);
        } catch (\Exception $e) {
            return json(['code' => 500, 'msg' => '更新失败: ' . $e->getMessage()]);
        }
    }
    
    /**
     * 删除角色（向后兼容方法）
     */
    public function del()
    {
        try {
            $param = Request::param();
            
            // 检查权限（只有超级管理员才能操作）
            if (!$this->checkSuperAdmin()) {
                return json(['code' => 403, 'msg' => '只有系统超级管理员才有权限操作角色！']);
            }
            
            // 数据验证
            if (empty($param['id'])) {
                return json(['code' => 400, 'msg' => '参数错误']);
            }
            
            // 检查角色是否存在
            $role = Db::name('admin_group')
                ->where('id', $param['id'])
                ->find();
            
            if (empty($role)) {
                return json(['code' => 404, 'msg' => '角色不存在']);
            }
            
            // 检查是否有用户使用该角色
            $userCount = Db::name('admin')->where('group_id', $param['id'])->count();
            if ($userCount > 0) {
                return json(['code' => 400, 'msg' => '该角色已被用户使用，无法删除']);
            }
            
            // 删除角色
            Db::name('admin_group')
                ->where('id', $param['id'])
                ->delete();
            
            return json(['code' => 0, 'msg' => '删除成功']);
        } catch (\Exception $e) {
            return json(['code' => 500, 'msg' => '删除失败: ' . $e->getMessage()]);
        }
    }
    
    /**
     * 复制角色权限
     * POST /api/home/role/{id}/copy
     */
    public function copy()
    {
        try {
            // 获取路径参数id
            $id = (int)Request::route('id');
            $body = Request::post(); // 获取请求体数据
            
            if ($id <= 0) {
                return $this->paramError('角色ID不能为空');
            }
            
            // 权限检查（只有超级管理员才能操作）
            if (!$this->checkSuperAdmin()) {
                return $this->error('只有系统超级管理员才有权限操作角色！', 403);
            }
            
            // 检查原角色是否存在
            $sourceRole = Db::name('admin_group')
                ->where('id', $id)
                ->find();
            
            if (empty($sourceRole)) {
                return $this->error('原角色不存在', 404);
            }
            
            // 数据验证
            if (empty($body['title'])) {
                return $this->paramError('新角色名称不能为空');
            }
            
            // 检查新角色名称是否已存在
            $existRole = Db::name('admin_group')
                ->where('title', trim($body['title']))
                ->find();
            
            if ($existRole) {
                return $this->error('角色名称已存在', 400);
            }
            
            // 复制角色数据
            $newRole = [
                'title' => trim($body['title']),
                'desc' => trim($body['desc'] ?? $sourceRole['title'] . '的副本'),
                'status' => (int)($body['status'] ?? 1),
                'rules' => $sourceRole['rules'],
                'layouts' => $sourceRole['layouts'],
                'create_time' => time(),
                'update_time' => time()
            ];
            
            // 创建新角色
            $newRoleId = Db::name('admin_group')->insertGetId($newRole);
            
            return $this->created(['id' => $newRoleId], '角色复制成功');
        } catch (\Exception $e) {
            return $this->error('复制失败: ' . $e->getMessage(), 500);
        }
    }
    
    /**
     * 获取启用的角色列表
     * GET /api/home/role/active-list
     */
    public function activeList()
    {
        try {
            // 查询启用的角色列表
            $list = Db::name('admin_group')
                ->where('status', 1)
                ->order('create_time', 'asc')
                ->select()
                ->toArray();
            
            return $this->success($list, '获取启用的角色列表成功');
        } catch (\Exception $e) {
            return $this->error('查询失败: ' . $e->getMessage(), 500);
        }
    }
    
    /**
     * 批量更新角色状态
     * POST /api/home/role/batch-status
     */
    public function batchUpdateStatus()
    {
        try {
            $body = Request::post();
            
            // 权限检查（只有超级管理员才能操作）
            if (!$this->checkSuperAdmin()) {
                return $this->error('只有系统超级管理员才有权限操作角色！', 403);
            }
            
            // 数据验证
            if (empty($body['ids']) || !is_array($body['ids'])) {
                return $this->paramError('角色ID列表不能为空');
            }
            
            if (!isset($body['status']) || !in_array($body['status'], [0, 1])) {
                return $this->paramError('状态只能是0（禁用）或1（正常）');
            }
            
            // 批量更新角色状态
            Db::name('admin_group')
                ->whereIn('id', $body['ids'])
                ->update([
                    'status' => (int)$body['status'],
                    'update_time' => time()
                ]);
            
            return $this->success('角色状态批量更新成功');
        } catch (\Exception $e) {
            return $this->error('批量更新失败: ' . $e->getMessage(), 500);
        }
    }
}